#pragma once

#include <mbgl/actor/mailbox.hpp>
#include <mbgl/actor/message.hpp>
#include <mbgl/actor/actor_ref.hpp>

#include <memory>
#include <future>
#include <type_traits>
#include <cassert>

namespace mbgl {

template <class Object>
class EstablishedActor;

template <class Object>
class Actor;

/**
    An `AspiringActor<O>` is one half of the pair of types that comprise an
   actor (see `Actor<O>`), the other half being `EstablishedActor<O>`.  It is
   responsible for:
     - ownership of the actor's `Mailbox`
     - allocating the memory for (but *not* constructing) the target object `O`

    Using these two pieces--the mailbox and a stable address for `O`--an
   `AspiringActor<O>` can accept messages for the target object, or provide
   `ActorRef<O>`s that do so, before the object has actually been constructed by
   the corresponding `EstablishedActor<O>`.  (Such messages are queued in the
   mailbox until after the object is constructed.)

    This allows for an `AspiringActor<O>` to be created and safely used by a
   thread other than the one on which the target object will (eventually) live.
*/
template <class Object>
class AspiringActor {
public:
    AspiringActor()
        : mailbox(std::make_shared<Mailbox>()) {
        // mailbox starts closed because the `Object` hasn't yet been constructed
        assert(!mailbox->isOpen());
    }

    AspiringActor(const AspiringActor&) = delete;

    ActorRef<std::decay_t<Object>> self() { return ActorRef<std::decay_t<Object>>(object(), mailbox); }

private:
    std::shared_ptr<Mailbox> mailbox;
    std::aligned_storage_t<sizeof(Object)> objectStorage;

    Object& object() { return reinterpret_cast<Object&>(objectStorage); }

    friend class EstablishedActor<Object>;
    friend class Actor<Object>;
};

} // namespace mbgl
